/**
 * @classdesc 图元基类，所有图元的父类
 * @class BaseGraphic
 * @extends BaseClass
 * @param {Object} options 配置参数
 * @param {String} [options.id] 图元唯一标识，默认自动创建
 * @param {Array<Number>} [options.position] 经纬度坐标[x,y,z]，如[111,28,0]，需要单个坐标的图元传入此属性
 * @param {Array<Array>} [options.positions] 经纬度坐标串[[x,y,z],[x,y,z],...]，如[[111,28,0],[111.5,28.5,0],...]，需要多个坐标的图元传入此属性
 * @param {Object} [options.style] 图元样式信息
 * @param {Object} [options.userData] 用户设置的额外数据
 */
import BaseClass from './BaseClass.js';

class BaseGraphic extends BaseClass {
    /**
     * @constructor
     * @param {Object} options 配置参数
     */
    constructor(options = {}) {
        super(options);
        
        // 初始化属性
        this._id = options.id || `graphic_${Date.now()}_${Math.floor(Math.random() * 1000)}`;
        this._position = options.position || null;
        this._positions = options.positions || [];
        this._style = options.style || {};
        this._userData = options.userData || {};
        this._name = '';
        this._remarks = '';
        this._show = true;
        this._isSelected = false;
        this._editMode = false;
        
        // 内部属性
        this._cesiumEntity = null;
        this._graphicLayer = null;
    }

    /**
     * 获取图元包围球
     * @type {Cesium.BoundingSphere}
     * @readonly
     */
    get boundingSphere() {
        // 子类需要重写此方法，返回实际的包围球
        return null;
    }

    /**
     * 图元坐标 (笛卡尔)，如果该图元需要的是坐标串，则返回null
     * @type {Cesium.Cartesian3|null}
     * @readonly
     */
    get cartesian3() {
        if (!this._position || this._position.length < 2) {
            return null;
        }
        
        try {
            // 假设Cesium已加载，将经纬度转换为笛卡尔坐标
            return Cesium.Cartesian3.fromDegrees(
                this._position[0],
                this._position[1],
                this._position[2] || 0
            );
        } catch (e) {
            console.error('转换坐标失败:', e);
            return null;
        }
    }

    /**
     * 图元坐标串（笛卡尔），如果该图元需要的是单个坐标，则返回空数组[]
     * @type {Array<Cesium.Cartesian3>}
     * @readonly
     */
    get cartesian3Array() {
        const result = [];
        
        if (!Array.isArray(this._positions) || this._positions.length === 0) {
            return result;
        }
        
        try {
            // 假设Cesium已加载，将经纬度坐标串转换为笛卡尔坐标串
            this._positions.forEach(pos => {
                if (Array.isArray(pos) && pos.length >= 2) {
                    result.push(Cesium.Cartesian3.fromDegrees(
                        pos[0],
                        pos[1],
                        pos[2] || 0
                    ));
                }
            });
        } catch (e) {
            console.error('转换坐标串失败:', e);
        }
        
        return result;
    }

    /**
     * 几何坐标，转换为GeoJson时用到
     * @type {Array}
     * @readonly
     */
    get coordinates() {
        // 子类需要重写此方法，返回实际的几何坐标
        return [];
    }

    /**
     * 获取或设置图元是否进入编辑状态
     * @type {Boolean}
     */
    get editMode() {
        return this._editMode;
    }

    set editMode(value) {
        if (this._editMode !== value) {
            this._editMode = value;
            this.fire('editModeChanged', { editMode: value });
        }
    }

    /**
     * 几何类型，转换为GeoJson时用到
     * @type {String}
     * @readonly
     */
    get geometryType() {
        // 子类需要重写此方法，返回实际的几何类型
        return 'Unknown';
    }

    /**
     * 图元所属分类
     * @type {GraphicClassType}
     * @readonly
     */
    get graphicClassType() {
        // 子类需要重写此方法，返回实际的图元分类
        return 'BASE';
    }

    /**
     * 图元类型
     * @type {GraphicType}
     * @readonly
     */
    get graphicType() {
        // 子类需要重写此方法，返回实际的图元类型
        return 'BASE';
    }

    /**
     * 图元id 唯一标识
     * @type {String}
     * @readonly
     */
    get id() {
        return this._id;
    }

    /**
     * 获取或设置图元选中状态
     * @type {Boolean}
     */
    get isSelected() {
        return this._isSelected;
    }

    set isSelected(value) {
        if (this._isSelected !== value) {
            this._isSelected = value;
            this.fire('selectedChanged', { isSelected: value });
        }
    }

    /**
     * 获取或设置图元名称
     * @type {String}
     */
    get name() {
        return this._name;
    }

    set name(value) {
        this._name = value;
    }

    /**
     * 图元坐标（经纬度），如果该图元需要的是坐标串，则返回null
     * @type {Array|null}
     * @readonly
     */
    get position() {
        return this._position;
    }

    set position(value) {
        this._position = value;
    }

    /**
     * 图元坐标串（经纬度），如果该图元需要的是单个坐标，则返回空数组
     * @type {Array<Array>}
     * @readonly
     */
    get positions() {
        return this._positions;
    }
    
    set positions(value) {
        this._positions = value;
    }

    /**
     * 获取或设置图元备注
     * @type {String}
     */
    get remarks() {
        return this._remarks;
    }

    set remarks(value) {
        this._remarks = value;
    }

    /**
     * 获取或设置图元可见性，优先级小于GraphicLayer.show
     * @type {Boolean}
     */
    get show() {
        return this._show;
    }

    set show(value) {
        if (this._show !== value) {
            this._show = value;
            this.fire('showChanged', { show: value });
        }
    }

    /**
     * 获取或设置图元样式
     * @type {Object}
     */
    get style() {
        return this._style;
    }

    set style(value) {
        if (value && typeof value === 'object') {
            this._style = value;
            this.fire('styleChanged', { style: value });
        }
    }

    /**
     * 图元类型名称
     * @type {String}
     * @readonly
     */
    get typeName() {
        // 子类需要重写此方法，返回实际的图元类型名称
        return 'BaseGraphic';
    }

    /**
     * 获取或设置用户数据
     * @type {Object}
     */
    get userData() {
        return this._userData;
    }

    set userData(value) {
        this._userData = value;
    }

    /**
     * 设置图元坐标
     * @param {Array} position 坐标值，[x,y,z]
     */
    setPosition(position) {
        if (Array.isArray(position) && position.length >= 2) {
            this._position = position;
            this.fire('positionChanged', { position: position });
        }
    }

    /**
     * 设置图元坐标串
     * @param {Array<Array>} positions 坐标串，[[x,y,z],[x,y,z],...]
     */
    setPositions(positions) {
        if (Array.isArray(positions)) {
            this._positions = positions;
            this.fire('positionsChanged', { positions: positions });
        }
    }

    /**
     * 转为GeoJson对象
     * @returns {Object} 转换后的对象
     */
    toGeoJson() {
        // 子类需要重写此方法，实现具体的GeoJson转换逻辑
        return {
            type: 'Feature',
            properties: {
                id: this._id,
                name: this._name,
                typeName: this.typeName,
                userData: this._userData
            },
            geometry: {
                type: this.geometryType,
                coordinates: this.coordinates
            }
        };
    }

    /**
     * 下载到本地
     * @param {String} name 文件名称
     */
    downloadToLocalFile(name) {
        try {
            const geoJson = this.toGeoJson();
            const content = JSON.stringify(geoJson, null, 2);
            const blob = new Blob([content], { type: 'application/json' });
            const url = URL.createObjectURL(blob);
            
            const a = document.createElement('a');
            a.href = url;
            a.download = name || `${this._id}.geojson`;
            document.body.appendChild(a);
            a.click();
            document.body.removeChild(a);
            
            // 释放URL对象
            setTimeout(() => {
                URL.revokeObjectURL(url);
            }, 100);
        } catch (e) {
            console.error('下载文件失败:', e);
        }
    }

    /**
     * 销毁对象
     */
    destroy() {
        if (this.isDestroyed()) {
            return;
        }
        
        // 清理资源
        this._position = null;
        this._positions = null;
        this._style = null;
        this._userData = null;
        this._cesiumEntity = null;
        this._graphicLayer = null;
        
        super.destroy();
    }
}

// 导出类
export default BaseGraphic;